/**
 * 中文数学扩展封装 (zh-math.js)
 * 支持基本数学运算、三角函数、矩阵、向量运算、随机数生成、链式调用
 * 整合了zh-number.js的功能，提供完整的数学操作API
 * 中文方法命名 + JSDoc 参数提示
 */

// 数学常量
const PI = Math.PI;
const 弧度转角度 = 180 / PI;
const DEG_TO_RAD = Math.PI / 180;

/**
 * 数学扩展主类
 */
class 数学 {
  /**
   * 构造函数 - 创建数学计算实例
   * @param {number|string} [值=0] 初始数值
   */
  constructor(值 = 0) {
    this._值 = Number(值) || 0;
  }

  /**
   * 获取当前值
   * @returns {number} 当前数值
   */
  取值() {
    return this._值;
  }

  /**
   * 设置值
   * @param {number|string} 值 要设置的数值
   * @returns {数学} 返回this以支持链式调用
   */
  设置值(值) {
    this._值 = Number(值) || 0;
    return this;
  }

  /**
   * 加法运算
   * @param {number|string} 数值 要相加的数值
   * @returns {数学} 返回this以支持链式调用
   */
  加(数值) {
    this._值 += Number(数值) || 0;
    return this;
  }

  /**
   * 减法运算
   * @param {number|string} 数值 要相减的数值
   * @returns {数学} 返回this以支持链式调用
   */
  减(数值) {
    this._值 -= Number(数值) || 0;
    return this;
  }

  /**
   * 乘法运算
   * @param {number|string} 数值 要相乘的数值
   * @returns {数学} 返回this以支持链式调用
   */
  乘(数值) {
    this._值 *= Number(数值) || 0;
    return this;
  }

  /**
   * 除法运算
   * @param {number|string} 数值 除数
   * @returns {数学} 返回this以支持链式调用
   */
  除(数值) {
    const 除数 = Number(数值) || 0;
    if (除数 === 0) {
      this._值 = NaN;
    } else {
      this._值 /= 除数;
    }
    return this;
  }

  /**
   * 取余运算
   * @param {number|string} 数值 除数
   * @returns {数学} 返回this以支持链式调用
   */
  取余(数值) {
    this._值 %= Number(数值) || 0;
    return this;
  }

  /**
   * 幂运算
   * @param {number|string} 指数 指数值
   * @returns {数学} 返回this以支持链式调用
   */
  幂(指数) {
    this._值 = Math.pow(this._值, Number(指数) || 0);
    return this;
  }

  /**
   * 计算平方根
   * @returns {数学} 返回this以支持链式调用
   */
  平方根() {
    this._值 = Math.sqrt(this._值);
    return this;
  }

  /**
   * 计算立方根
   * @returns {数学} 返回this以支持链式调用
   */
  立方根() {
    this._值 = Math.cbrt(this._值);
    return this;
  }
  
  /**
   * 取整数部分
   * @returns {数学} 返回this以支持链式调用
   */
  取整() {
    this._值 = Math.trunc(this._值);
    return this;
  }
  
  /**
   * 打印当前值到控制台
   * @returns {数学} 返回this以支持链式调用
   */
  打印() {
    console.log(this._值);
    return this;
  }
  
  /**
   * 转换为字符串
   * @returns {数学} 返回this以支持链式调用
   */
  转字符串() {
    this._值 = this._值.toString();
    return this;
  }
  
  /**
   * 转换为本地化字符串
   * @param {string} [语言='zh-CN'] 语言代码
   * @param {Object} [选项={}] 格式化选项
   * @returns {数学} 返回this以支持链式调用
   */
  转本地字符串(语言 = 'zh-CN', 选项 = {}) {
    this._值 = this._值.toLocaleString(语言, 选项);
    return this;
  }
  
  /**
   * 转换为固定小数位的字符串
   * @param {number} [位数=0] 小数位数
   * @returns {数学} 返回this以支持链式调用
   */
  固定小数(位数 = 0) {
    this._值 = this._值.toFixed(位数);
    return this;
  }
  
  /**
   * 转换为指定精度的字符串
   * @param {number} 位数 有效位数
   * @returns {数学} 返回this以支持链式调用
   */
  精度(位数) {
    this._值 = this._值.toPrecision(位数);
    return this;
  }
  
  /**
   * 转换为科学计数法字符串
   * @param {number} 位数 小数位数
   * @returns {数学} 返回this以支持链式调用
   */
  科学记数(位数) {
    this._值 = this._值.toExponential(位数);
    return this;
  }

  /**
   * 计算绝对值
   * @returns {数学} 返回this以支持链式调用
   */
  绝对值() {
    this._值 = Math.abs(this._值);
    return this;
  }

  /**
   * 向上取整
   * @returns {数学} 返回this以支持链式调用
   */
  向上取整() {
    this._值 = Math.ceil(this._值);
    return this;
  }

  /**
   * 向下取整
   * @returns {数学} 返回this以支持链式调用
   */
  向下取整() {
    this._值 = Math.floor(this._值);
    return this;
  }

  /**
   * 四舍五入到指定精度
   * @param {number} [精度=0] 小数位数精度
   * @returns {数学} 返回this以支持链式调用
   */
  四舍五入(精度 = 0) {
    const 因子 = Math.pow(10, 精度);
    this._值 = Math.round(this._值 * 因子) / 因子;
    return this;
  }

  /**
   * 将弧度值转换为角度值
   * @returns {数学} 返回this以支持链式调用
   */
  弧度转角度() {
    this._值 *= 弧度转角度;
    return this;
  }

  /**
   * 将角度值转换为弧度值
   * @returns {数学} 返回this以支持链式调用
   */
  角度转弧度() {
    this._值 *= DEG_TO_RAD;
    return this;
  }

  /**
   * 计算正弦值（输入弧度）
   * @returns {数学} 返回this以支持链式调用
   */
  正弦() {
    this._值 = Math.sin(this._值);
    return this;
  }

  /**
   * 计算余弦值（输入弧度）
   * @returns {数学} 返回this以支持链式调用
   */
  余弦() {
    this._值 = Math.cos(this._值);
    return this;
  }

  /**
   * 计算正切值（输入弧度）
   * @returns {数学} 返回this以支持链式调用
   */
  正切() {
    this._值 = Math.tan(this._值);
    return this;
  }

  /**
   * 计算反正弦值（返回弧度）
   * @returns {数学} 返回this以支持链式调用
   */
  反正弦() {
    this._值 = Math.asin(this._值);
    return this;
  }

  /**
   * 计算反余弦值（返回弧度）
   * @returns {数学} 返回this以支持链式调用
   */
  反余弦() {
    this._值 = Math.acos(this._值);
    return this;
  }

  /**
   * 计算反正切值（返回弧度）
   * @returns {数学} 返回this以支持链式调用
   */
  反正切() {
    this._值 = Math.atan(this._值);
    return this;
  }

  /**
   * 计算反正切2值（返回弧度）
   * @param {number} y y坐标
   * @returns {数学} 返回this以支持链式调用
   */
  反正切2(y) {
    this._值 = Math.atan2(this._值, y);
    return this;
  }

  /**
   * 计算双曲正弦值
   * @returns {数学} 返回this以支持链式调用
   */
  双曲正弦() {
    this._值 = Math.sinh(this._值);
    return this;
  }

  /**
   * 计算双曲余弦值
   * @returns {数学} 返回this以支持链式调用
   */
  双曲余弦() {
    this._值 = Math.cosh(this._值);
    return this;
  }

  /**
   * 计算双曲正切值
   * @returns {数学} 返回this以支持链式调用
   */
  双曲正切() {
    this._值 = Math.tanh(this._值);
    return this;
  }

  /**
   * 将值限制在指定范围内
   * @param {number} 最小值 最小值
   * @param {number} 最大值 最大值
   * @returns {数学} 返回this以支持链式调用
   */
  限制范围(最小值, 最大值) {
    this._值 = Math.min(Math.max(this._值, 最小值), 最大值);
    return this;
  }

  /**
   * 线性插值
   * @param {number} 目标值 目标数值
   * @param {number} 比例 插值比例（0-1）
   * @returns {数学} 返回this以支持链式调用
   */
  线性插值(目标值, 比例) {
    this._值 = this._值 + (目标值 - this._值) * 比例;
    return this;
  }

  /**
   * 创建当前实例的副本
   * @returns {数学} 新的数学实例
   */
  克隆() {
    return new 数学(this._值);
  }

  /**
   * 转换为整数
   * @returns {数学} 返回this以支持链式调用
   */
  转整数() {
    this._值 = parseInt(this._值, 10);
    return this;
  }

  /**
   * 转换为浮点数
   * @returns {数学} 返回this以支持链式调用
   */
  转浮点数() {
    this._值 = parseFloat(this._值);
    return this;
  }

  /**
   * 判断当前值是否为整数
   * @returns {boolean} 是否为整数
   */
  是整数() {
    return Number.isInteger(this._值);
  }

  /**
   * 判断当前值是否为有限数
   * @returns {boolean} 是否为有限数
   */
  是有限数() {
    return Number.isFinite(this._值);
  }

  /**
   * 判断当前值是否为NaN
   * @returns {boolean} 是否为NaN
   */
  是NaN() {
    return Number.isNaN(this._值);
  }

  /** 静态方法 */

  /**
   * 静态方法：创建数学实例
   * @static
   * @param {number|string} [值=0] 初始数值
   * @returns {数学} 新的数学实例
   */
  static 创建(值 = 0) {
    return new 数学(值);
  }

  /**
   * 静态方法：计算两点之间的距离
   * @static
   * @param {number} x1 第一个点的x坐标
   * @param {number} y1 第一个点的y坐标
   * @param {number} x2 第二个点的x坐标
   * @param {number} y2 第二个点的y坐标
   * @returns {number} 两点之间的距离
   */
  static 距离(x1, y1, x2, y2) {
    return Math.sqrt(Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 2));
  }

  /**
   * 静态方法：计算二维向量长度
   * @static
   * @param {number} x 向量x分量
   * @param {number} y 向量y分量
   * @returns {number} 向量长度
   */
  static 向量长度(x, y) {
    return Math.sqrt(x * x + y * y);
  }

  /**
   * 静态方法：计算二维向量点积
   * @static
   * @param {number} x1 第一个向量x分量
   * @param {number} y1 第一个向量y分量
   * @param {number} x2 第二个向量x分量
   * @param {number} y2 第二个向量y分量
   * @returns {number} 点积结果
   */
  static 向量点积(x1, y1, x2, y2) {
    return x1 * x2 + y1 * y2;
  }

  /**
   * 静态方法：计算二维向量叉积
   * @static
   * @param {number} x1 第一个向量x分量
   * @param {number} y1 第一个向量y分量
   * @param {number} x2 第二个向量x分量
   * @param {number} y2 第二个向量y分量
   * @returns {number} 叉积结果
   */
  static 向量叉积(x1, y1, x2, y2) {
    return x1 * y2 - y1 * x2;
  }

  /**
   * 静态方法：归一化二维向量
   * @static
   * @param {number} x 向量x分量
   * @param {number} y 向量y分量
   * @returns {Object} 归一化后的向量对象 {x, y}
   */
  static 归一化向量(x, y) {
    const 长度 = 数学.向量长度(x, y);
    if (长度 === 0) return { x: 0, y: 0 };
    return { x: x / 长度, y: y / 长度 };
  }

  /**
   * 静态方法：生成随机浮点数
   * @static
   * @param {number} [最小值=0] 最小值（包含）
   * @param {number} [最大值=1] 最大值（不包含）
   * @returns {number} 随机浮点数
   */
  static 随机数(最小值 = 0, 最大值 = 1) {
    return Math.random() * (最大值 - 最小值) + 最小值;
  }

  /**
   * 静态方法：生成随机整数
   * @static
   * @param {number} [最小值=0] 最小值（包含）
   * @param {number} [最大值=1] 最大值（包含）
   * @returns {number} 随机整数
   */
  static 随机整数(最小值 = 0, 最大值 = 1) {
    最小值 = Math.ceil(最小值);
    最大值 = Math.floor(最大值);
    return Math.floor(Math.random() * (最大值 - 最小值 + 1)) + 最小值;
  }

  /**
   * 静态方法：生成随机布尔值
   * @static
   * @returns {boolean} 随机布尔值
   */
  static 随机布尔值() {
    return Math.random() > 0.5;
  }

  /**
   * 静态方法：生成随机字符串
   * @static
   * @param {number} [长度=8] 字符串长度
   * @param {string} [字符集='abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'] 可选字符集
   * @returns {string} 随机字符串
   */
  static 随机字符串(长度 = 8, 字符集 = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789') {
    let 结果 = '';
    for (let i = 0; i < 长度; i++) {
      结果 += 字符集[数学.随机整数(0, 字符集.length - 1)];
    }
    return 结果;
  }

  /**
   * 静态方法：矩阵乘法运算
   * @static
   * @param {Array<Array<number>>} 矩阵A 第一个矩阵
   * @param {Array<Array<number>>} 矩阵B 第二个矩阵
   * @returns {Array<Array<number>>} 乘积结果矩阵
   */
  static 矩阵乘法(矩阵A, 矩阵B) {
    const 行A = 矩阵A.length;
    const 列A = 矩阵A[0].length;
    const 列B = 矩阵B[0].length;
    
    const 结果 = Array(行A).fill(null).map(() => Array(列B).fill(0));
    
    for (let i = 0; i < 行A; i++) {
      for (let j = 0; j < 列B; j++) {
        for (let k = 0; k < 列A; k++) {
          结果[i][j] += 矩阵A[i][k] * 矩阵B[k][j];
        }
      }
    }
    
    return 结果;
  }

  /**
   * 静态方法：矩阵加法运算
   * @static
   * @param {Array<Array<number>>} 矩阵A 第一个矩阵
   * @param {Array<Array<number>>} 矩阵B 第二个矩阵
   * @returns {Array<Array<number>>} 加法结果矩阵
   */
  static 矩阵加法(矩阵A, 矩阵B) {
    const 行 = 矩阵A.length;
    const 列 = 矩阵A[0].length;
    
    const 结果 = Array(行).fill(null).map(() => Array(列).fill(0));
    
    for (let i = 0; i < 行; i++) {
      for (let j = 0; j < 列; j++) {
        结果[i][j] = 矩阵A[i][j] + 矩阵B[i][j];
      }
    }
    
    return 结果;
  }

  /**
   * 静态方法：矩阵与标量乘法
   * @static
   * @param {Array<Array<number>>} 矩阵 要相乘的矩阵
   * @param {number} 标量 标量值
   * @returns {Array<Array<number>>} 乘法结果矩阵
   */
  static 矩阵标量乘法(矩阵, 标量) {
    return 矩阵.map(行 => 行.map(元素 => 元素 * 标量));
  }

  /**
   * 静态方法：创建单位矩阵
   * @static
   * @param {number} 大小 矩阵维度
   * @returns {Array<Array<number>>} 单位矩阵
   */
  static 创建单位矩阵(大小) {
    const 矩阵 = Array(大小).fill(null).map(() => Array(大小).fill(0));
    for (let i = 0; i < 大小; i++) {
      矩阵[i][i] = 1;
    }
    return 矩阵;
  }

  /**
   * 静态方法：创建2D旋转矩阵
   * @static
   * @param {number} 角度 旋转角度（度数）
   * @returns {Array<Array<number>>} 旋转矩阵
   */
  static 创建旋转矩阵(角度) {
    const 弧度 = 角度 * DEG_TO_RAD;
    const 余弦 = Math.cos(弧度);
    const 正弦 = Math.sin(弧度);
    return [[余弦, -正弦], [正弦, 余弦]];
  }

  /**
   * 静态方法：创建2D缩放矩阵
   * @static
   * @param {number} 缩放X X轴缩放比例
   * @param {number} 缩放Y Y轴缩放比例
   * @returns {Array<Array<number>>} 缩放矩阵
   */
  static 创建缩放矩阵(缩放X, 缩放Y) {
    return [[缩放X, 0], [0, 缩放Y]];
  }

  /**
   * 静态方法：创建2D平移矩阵
   * @static
   * @param {number} 平移X X轴平移量
   * @param {number} 平移Y Y轴平移量
   * @returns {Array<Array<number>>} 平移矩阵
   */
  static 创建平移矩阵(平移X, 平移Y) {
    return [[1, 0, 平移X], [0, 1, 平移Y], [0, 0, 1]];
  }

  /**
   * 静态方法：计算平均值
   * @static
   * @param {...number} 数值 要计算平均值的数值序列
   * @returns {number} 平均值
   */
  static 平均值(...数值) {
    return 数值.reduce((总和, 数) => 总和 + 数, 0) / 数值.length;
  }

  /**
   * 静态方法：计算中位数
   * @static
   * @param {...number} 数值 要计算中位数的数值序列
   * @returns {number} 中位数
   */
  static 中位数(...数值) {
    const 排序后的数组 = [...数值].sort((a, b) => a - b);
    const 中间位置 = Math.floor(排序后的数组.length / 2);
    
    if (排序后的数组.length % 2 === 0) {
      return (排序后的数组[中间位置 - 1] + 排序后的数组[中间位置]) / 2;
    } else {
      return 排序后的数组[中间位置];
    }
  }

  /**
   * 静态方法：计算标准差
   * @static
   * @param {...number} 数值 要计算标准差的数值序列
   * @returns {number} 标准差
   */
  static 标准差(...数值) {
    const 平均值 = 数学.平均值(...数值);
    const 方差 = 数值.reduce((总和, 数) => 总和 + Math.pow(数 - 平均值, 2), 0) / 数值.length;
    return Math.sqrt(方差);
  }

  /**
   * 静态方法：标准化角度到0-360度范围
   * @static
   * @param {number} 角度 角度值（度数）
   * @returns {number} 标准化后的角度
   */
  static 标准化角度(角度) {
    角度 = 角度 % 360;
    return 角度 < 0 ? 角度 + 360 : 角度;
  }

  /**
   * 静态方法：计算两角度之间的最小差值
   * @static
   * @param {number} 角度1 第一个角度（度数）
   * @param {number} 角度2 第二个角度（度数）
   * @returns {number} 最小角度差值
   */
  static 角度差值(角度1, 角度2) {
    const 差 = (角度2 - 角度1 + 180) % 360 - 180;
    return 差 < -180 ? 差 + 360 : 差 > 180 ? 差 - 360 : 差;
  }
  
  /**
   * 静态方法：获取数的符号
   * @static
   * @param {number} v 数值
   * @returns {number} 符号（-1, 0, 1）
   */
  static 取符号(v) {
    return Math.sign(v);
  }
  
  /**
   * 静态方法：计算自然对数
   * @static
   * @param {number} v 数值
   * @returns {number} 自然对数值
   */
  static 取对数(v) {
    return Math.log(v);
  }
  
  /**
   * 静态方法：计算以10为底的对数
   * @static
   * @param {number} v 数值
   * @returns {number} 以10为底的对数值
   */
  static 取对数10(v) {
    return Math.log10(v);
  }
  
  /**
   * 静态方法：计算以2为底的对数
   * @static
   * @param {number} v 数值
   * @returns {number} 以2为底的对数值
   */
  static 取对数2(v) {
    return Math.log2(v);
  }
  
  /**
   * 静态方法：解析字符串为浮点数
   * @static
   * @param {string} str 要解析的字符串
   * @returns {number} 解析后的浮点数
   */
  static 解析浮点(str) {
    return parseFloat(str);
  }
  
  /**
   * 静态方法：解析字符串为整数
   * @static
   * @param {string} str 要解析的字符串
   * @param {number} [基数=10] 进制基数
   * @returns {number} 解析后的整数
   */
  static 解析整数(str, 基数 = 10) {
    return parseInt(str, 基数);
  }
  
  /**
   * 静态方法：计算平方
   * @static
   * @param {number} v 数值
   * @returns {number} 平方值
   */
  static 平方(v) {
    return v * v;
  }
  
  /**
   * 静态方法：计算立方
   * @static
   * @param {number} v 数值
   * @returns {number} 立方值
   */
  static 立方(v) {
    return v * v * v;
  }
  
  /**
   * 静态方法：获取一组数中的最大值（别名）
   * @static
   * @param {...number} args 数值列表
   * @returns {number} 最大值
   */
  static 取最大(...args) {
    return Math.max(...args);
  }
  
  /**
   * 静态方法：获取一组数中的最小值（别名）
   * @static
   * @param {...number} args 数值列表
   * @returns {number} 最小值
   */
  static 取最小(...args) {
    return Math.min(...args);
  }
  
  /**
   * 静态方法：生成0到1之间的随机数（别名）
   * @static
   * @returns {number} 随机数
   */
  static 随机() {
    return Math.random();
  }
  
  /**
   * 静态方法：四舍五入（别名）
   * @static
   * @param {number} v 数值
   * @returns {number} 四舍五入后的整数
   */
  static 四舍五入数(v) {
    return Math.round(v);
  }
  
  /**
   * 静态方法：向下取整（别名）
   * @static
   * @param {number} v 数值
   * @returns {number} 向下取整后的整数
   */
  static 向下取整数(v) {
    return Math.floor(v);
  }
  
  /**
   * 静态方法：向上取整（别名）
   * @static
   * @param {number} v 数值
   * @returns {number} 向上取整后的整数
   */
  static 向上取整数(v) {
    return Math.ceil(v);
  }
  
  /**
   * 静态方法：计算绝对值（别名）
   * @static
   * @param {number} v 数值
   * @returns {number} 绝对值
   */
  static 绝对值数(v) {
    return Math.abs(v);
  }
}

// 向量类
class 向量 {
  /**
   * 构造函数 - 创建三维向量
   * @param {number} [x=0] x分量
   * @param {number} [y=0] y分量
   * @param {number} [z=0] z分量
   */
  constructor(x = 0, y = 0, z = 0) {
    this.x = x;
    this.y = y;
    this.z = z;
  }

  /**
   * 计算向量长度
   * @returns {number} 向量长度
   */
  获取长度() {
    return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
  }

  /**
   * 归一化向量（单位向量）
   * @returns {向量} 返回this以支持链式调用
   */
  归一化() {
    const 长度 = this.获取长度();
    if (长度 > 0) {
      this.x /= 长度;
      this.y /= 长度;
      this.z /= 长度;
    }
    return this;
  }

  /**
   * 向量加法
   * @param {向量} 向量 要相加的向量
   * @returns {向量} 返回this以支持链式调用
   */
  加(向量) {
    this.x += 向量.x;
    this.y += 向量.y;
    this.z += 向量.z;
    return this;
  }

  /**
   * 向量减法
   * @param {向量} 向量 要相减的向量
   * @returns {向量} 返回this以支持链式调用
   */
  减(向量) {
    this.x -= 向量.x;
    this.y -= 向量.y;
    this.z -= 向量.z;
    return this;
  }

  /**
   * 向量与标量乘法
   * @param {number} 标量 标量值
   * @returns {向量} 返回this以支持链式调用
   */
  乘(标量) {
    this.x *= 标量;
    this.y *= 标量;
    this.z *= 标量;
    return this;
  }

  /**
   * 计算向量点积
   * @param {向量} 向量 另一个向量
   * @returns {number} 点积结果
   */
  点积(向量) {
    return this.x * 向量.x + this.y * 向量.y + this.z * 向量.z;
  }

  /**
   * 计算向量叉积
   * @param {向量} 向量 另一个向量
   * @returns {向量} 叉积结果向量
   */
  叉积(向量) {
    return new 向量(
      this.y * 向量.z - this.z * 向量.y,
      this.z * 向量.x - this.x * 向量.z,
      this.x * 向量.y - this.y * 向量.x
    );
  }

  /**
   * 计算与另一个向量的距离
   * @param {向量} 向量 另一个向量
   * @returns {number} 向量间距离
   */
  距离(向量) {
    const dx = this.x - 向量.x;
    const dy = this.y - 向量.y;
    const dz = this.z - 向量.z;
    return Math.sqrt(dx * dx + dy * dy + dz * dz);
  }

  /**
   * 创建向量副本
   * @returns {向量} 新的向量实例
   */
  克隆() {
    return new 向量(this.x, this.y, this.z);
  }

  /**
   * 转换为数组 [x, y, z]
   * @returns {Array<number>} 向量数组表示
   */
  转数组() {
    return [this.x, this.y, this.z];
  }
}

// 矩阵类
 class 矩阵 {
  /**
   * 构造函数 - 创建矩阵
   * @param {number} 行数 矩阵行数
   * @param {number} 列数 矩阵列数
   */
  constructor(行数, 列数) {
    this._数据 = Array(行数).fill(null).map(() => Array(列数).fill(0));
    this._行数 = 行数;
    this._列数 = 列数;
  }

  /**
   * 设置矩阵元素值
   * @param {number} 行 行索引
   * @param {number} 列 列索引
   * @param {number} 值 要设置的值
   * @returns {矩阵} 返回this以支持链式调用
   */
  设置值(行, 列, 值) {
    if (行 >= 0 && 行 < this._行数 && 列 >= 0 && 列 < this._列数) {
      this._数据[行][列] = 值;
    }
    return this;
  }

  /**
   * 获取矩阵元素值
   * @param {number} 行 行索引
   * @param {number} 列 列索引
   * @returns {number|undefined} 元素值或undefined（索引越界时）
   */
  获取值(行, 列) {
    if (行 >= 0 && 行 < this._行数 && 列 >= 0 && 列 < this._列数) {
      return this._数据[行][列];
    }
    return undefined;
  }

  /**
   * 获取矩阵数据的深拷贝
   * @returns {Array<Array<number>>} 矩阵数据
   */
  取值() {
    return this._数据.map(行 => [...行]);
  }

  /**
   * 创建矩阵副本
   * @returns {矩阵} 新的矩阵实例
   */
  克隆() {
    const 新矩阵 = new 矩阵(this._行数, this._列数);
    for (let i = 0; i < this._行数; i++) {
      for (let j = 0; j < this._列数; j++) {
        新矩阵._数据[i][j] = this._数据[i][j];
      }
    }
    return 新矩阵;
  }
}



// CommonJS 导出

  module.exports = {
    数学,
    default: 数学,
    default: 向量
  };
  module.exports.数学 = 数学;
module.exports.向量 = 向量;

// ES 模块导出
// export { 数学 };
// export default 数学;

